home *** CD-ROM | disk | FTP | other *** search
/ Komputer for Alle 2002 #4 / K-CD-4-2002.ISO / Empire Earth / EEDemo.exe / Disk1 / Random Map Scripts / Plains / Plains Large.rmv < prev    next >
Encoding:
Text File  |  2001-09-27  |  49.9 KB  |  1,485 lines

  1. //////////////////////////////////////////////////////////////////////
  2. //
  3. // Plains Large.rmv
  4. //
  5. //
  6. // Plains definitions for large maps.
  7. //
  8. // Copyright (c) 2000, Stainless Steel Studios, Inc. All rights reserved.
  9. // PROPRIETARY and CONFIDENTIAL.
  10. //
  11. // $Creator: Richard Bishop $
  12. // $Date: 9/13/01 12:31p $
  13. //      V1.1 to V1.2
  14. //        -Pulled in Berries two tiles closer
  15. //    V1.2 to V1.3
  16. //        -Added Tigers to all maps
  17. //        -Added Hippos to all maps
  18. //////////////////////////////////////////////////////////////////////
  19.  
  20. #if            NOTDEFINED(PLAINS_LARGE_RMV)
  21. #define        (PLAINS_LARGE_RMV,1)
  22.  
  23. //////////////////////////////////////////////////////////////////////
  24. // Resource
  25.  
  26. #if OR(IsPaleoEpoch, IsStoneEpoch) 
  27.   #define  (kBerryPerPlayer,    2)
  28. #else
  29.   #define  (kBerryPerPlayer,    1)
  30. #endif
  31.  
  32. PlaceResourceInRing (Gold, 25, 30)
  33. PlaceResourceInRing (Iron, 25, 30)
  34. PlaceResourceInRing (Stone, 22, 24)
  35.  
  36. PlaceResourceInRing (Gold, 14, 16)
  37. PlaceResourceInRing (Iron, 15, 17)
  38.  
  39. //////////////////////////////////////////////////////////////////////
  40. // Placing Starting Hippos
  41.  
  42. #if DEFINED(kWinterMap)
  43.   PlaceWorldUnitInRing (Res-Walrus, 12, 12)
  44.   PlaceWorldUnitInRing (Res-Walrus, 12, 12)
  45. #else 
  46.   PlaceWorldUnitInRing (Res-Hippopotamus, 12, 12)
  47.   PlaceWorldUnitInRing (Res-Hippopotamus, 12, 12)
  48. #endif
  49.  
  50. //////////////////////////////////////////////////////////////////////
  51. // Placing Aggressive Animals
  52.  
  53. PlaceWorldUnitInRing (Res-Tiger, 33, 35)
  54. PlaceWorldUnitInRing (Res-Tiger, 28, 29)
  55.  
  56. //////////////////////////////////////////////////////////////////////
  57. // Resource Limitations
  58. ResourcePlacementLimit (Gold,     10,    12)
  59. ResourcePlacementLimit (Steel,     10,     12)
  60. ResourcePlacementLimit (Berry,     6,    7)
  61. ResourcePlacementLimit (Stone,     14,    15)
  62. ResourcePlacementLimit (Tree,     3,    5)
  63.  
  64. #if Is2Players
  65. //////////////////////////////////////////////////////////////////////
  66. // 2 PLAYERS...
  67. //////////////////////////////////////////////////////////////////////
  68.  
  69. ResourceSeperation    8 
  70.  
  71. //////////////////////////////////////////////////////////////////////
  72. // terrain definitions
  73. HeightMapSmoothness                    0
  74. #define        (kMaxIntElevation,            12)
  75. #define        (kElevationScale,                Between(.5, .5))
  76. #define        (kHeightMapChaos,                Between(15, 15))
  77.                                             
  78. #define        (kMinimumStartPositionToMapEdge        4)
  79. #define        (kOuterPushFromMapCenter        25)
  80. #define        (kInnerPushFromMapCenter         0)    
  81.  
  82. #define        (kConvergentSampleSize,            3) 
  83. #define        (kConvergentThreshold,            15)    
  84.  
  85. //////////////////////////////////////////////////////////////////////
  86. // player definitions
  87. #define        (kMaxAngleBetweenTeamMembers,        75.0)
  88. #define        (kPlayerInnerRadius,            0.6)
  89. #define        (kPlayerOuterRadius,            0.99)
  90. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  91. #define        (kPlayerPercentFlat,            Between(0.8, 0.8))
  92. #define        (kPlayerLandChaos,            0.8)
  93. #define        (kPlayerLandClumps,            Between(2, 2))
  94. #define        (kPlayerFlatChaos,            0.8)
  95. #define        (kPlayerFlatClumps,            Between(1, 2))
  96. #define        (kPlayerTreePercentage,            0.04)
  97.  
  98. //////////////////////////////////////////////////////////////////////
  99. // inner neutral definitions
  100. #define        (kNeutralInnerRadius,            0.1)
  101. #define        (kNeutralOuterRadius,            0.5)
  102. #define        (kNeutralOptimalFactor,            0.7)
  103. #define        (kNumInnerNeutrals,                 Between(11, 11))
  104. #define        (kInnerNeutralPercentLand,        0.2)
  105. #define        (kInnerNeutralPercentFlat,        Between(0.5, 0.5))
  106. #define        (kInnerNeutralTreePercentage,          0.1)
  107. #define        (kInnerNeutralLandChaos,        0.8)
  108. #define        (kInnerNeutralLandClumps,        Between(2, 2))
  109. #define        (kInnerNeutralFlatChaos,        0.8)
  110. #define        (kInnerNeutralFlatClumps,        Between(1, 1))
  111.  
  112. //////////////////////////////////////////////////////////////////////
  113. // outer neutral definitions
  114. #define        (kNumOuterNeutrals,            Between(20, 20))
  115. #define        (kOuterNeutralPercentLand,        0.5)
  116. #define        (kOuterNeutralPercentFlat,        Between(0.4, 0.4))
  117. #define        (kOuterNeutralTreePercentage,          0.1)
  118. #define        (kOuterNeutralLandChaos,        0.8)
  119. #define        (kOuterNeutralLandClumps,        Between(2, 2))
  120. #define        (kOuterNeutralFlatChaos,        0.8)
  121. #define        (kOuterNeutralFlatClumps,        Between(1, 1))
  122.  
  123.  
  124. //////////////////////////////////////////////////////////////////////
  125. // resource definitions
  126. #define        (kMaxResourceElevation,            2)
  127. #define        (kResourceToEdgeDistance,        2)
  128. #define        (kResourceToWaterDistance,        3)
  129.  
  130. #define        (kAnimalPerPlayer,                0)
  131. #define        (kAnimalPerNeutral,                0)
  132.  
  133.  
  134. #define        (kBerryPerNeutral,                0)
  135.  
  136. #define        (kFishPerPlayer,                0)
  137. #define        (kFishPerNeutral,                0)
  138.  
  139. #define        (kGoldPerPlayer,                1)
  140. #define        (kGoldPerNeutral,                5)
  141.  
  142. #define        (kOilPerPlayer,                    0)
  143. #define        (kOilPerNeutral,                0)
  144.  
  145. #define        (kSteelPerPlayer,                1)
  146. #define        (kSteelPerNeutral,                5)
  147.  
  148. #define        (kStonePerPlayer,                1)
  149. #define        (kStonePerNeutral,                1)
  150.  
  151. #define        (kTreePerPlayer,                Between(2, 3))
  152. #define        (kTreePerNeutral,                0)
  153.  
  154. //////////////////////////////////////////////////////////////////////
  155. // forest definitions
  156. #define        (kForestFreeRadius,                8.0)
  157. #define        (kForestsPerPlayer,                2)
  158. #define        (kForestChaosLevel,                1)
  159. #define        (kMaxClumpsPerForest,                  2)
  160.  
  161. #elif Is3Players
  162. //////////////////////////////////////////////////////////////////////
  163. // 3 PLAYERS...
  164. //////////////////////////////////////////////////////////////////////
  165.  
  166. ResourceSeperation    8 
  167.  
  168. PlaceResourceInRing (Iron, 40, 45)
  169. PlaceResourceInRing (Gold, 40, 45)
  170.  
  171. //////////////////////////////////////////////////////////////////////
  172. // terrain definitions
  173. HeightMapSmoothness                    0
  174. #define        (kMaxIntElevation,            12)
  175. #define        (kElevationScale,                Between(.5, .5))
  176. #define        (kHeightMapChaos,                Between(15, 15))
  177.                                             
  178. #define        (kMinimumStartPositionToMapEdge        5)
  179. #define        (kOuterPushFromMapCenter        25)
  180. #define        (kInnerPushFromMapCenter         0)    
  181.     
  182. #define        (kConvergentSampleSize,            32) 
  183. #define        (kConvergentThreshold,            8)
  184.  
  185. //////////////////////////////////////////////////////////////////////
  186. // player definitions
  187. #define        (kMaxAngleBetweenTeamMembers,        75.0)
  188. #define        (kPlayerInnerRadius,            0.6)
  189. #define        (kPlayerOuterRadius,            0.99)
  190. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  191. #define        (kPlayerPercentFlat,            Between(0.8, 0.8))
  192. #define        (kPlayerLandChaos,            0.8)
  193. #define        (kPlayerLandClumps,            Between(2, 2))
  194. #define        (kPlayerFlatChaos,            0.8)
  195. #define        (kPlayerFlatClumps,            Between(1, 2))
  196. #define        (kPlayerTreePercentage,            0.04)
  197.  
  198. //////////////////////////////////////////////////////////////////////
  199. // inner neutral definitions
  200. #define        (kNeutralInnerRadius,            0.1)
  201. #define        (kNeutralOuterRadius,            0.5)
  202. #define        (kNeutralOptimalFactor,            0.7)
  203. #define        (kNumInnerNeutrals,                 Between(11, 11))
  204. #define        (kInnerNeutralPercentLand,        0.2)
  205. #define        (kInnerNeutralPercentFlat,        Between(0.5, 0.5))
  206. #define        (kInnerNeutralTreePercentage,          0.1)
  207. #define        (kInnerNeutralLandChaos,        0.8)
  208. #define        (kInnerNeutralLandClumps,        Between(2, 2))
  209. #define        (kInnerNeutralFlatChaos,        0.8)
  210. #define        (kInnerNeutralFlatClumps,        Between(1, 1))
  211.  
  212. //////////////////////////////////////////////////////////////////////
  213. // outer neutral definitions
  214. #define        (kNumOuterNeutrals,            Between(20, 20))
  215. #define        (kOuterNeutralPercentLand,        0.5)
  216. #define        (kOuterNeutralPercentFlat,        Between(0.4, 0.4))
  217. #define        (kOuterNeutralTreePercentage,          0.1)
  218. #define        (kOuterNeutralLandChaos,        0.8)
  219. #define        (kOuterNeutralLandClumps,        Between(2, 2))
  220. #define        (kOuterNeutralFlatChaos,        0.8)
  221. #define        (kOuterNeutralFlatClumps,        Between(1, 1))
  222.  
  223. //////////////////////////////////////////////////////////////////////
  224. // resource definitions
  225. #define        (kMaxResourceElevation,            2)
  226. #define        (kResourceToEdgeDistance,        2)
  227. #define        (kResourceToWaterDistance,        3)
  228.  
  229. #define        (kAnimalPerPlayer,                0)
  230. #define        (kAnimalPerNeutral,                0)
  231.  
  232.  
  233. #define        (kBerryPerNeutral,                0)
  234.  
  235. #define        (kFishPerPlayer,                0)
  236. #define        (kFishPerNeutral,                0)
  237.  
  238. #define        (kGoldPerPlayer,                1)
  239. #define        (kGoldPerNeutral,                2)
  240.  
  241. #define        (kOilPerPlayer,                    0)
  242. #define        (kOilPerNeutral,                0)
  243.  
  244. #define        (kSteelPerPlayer,                1)
  245. #define        (kSteelPerNeutral,                2)
  246.  
  247. #define        (kStonePerPlayer,                1)
  248. #define        (kStonePerNeutral,                1)
  249.  
  250. #define        (kTreePerPlayer,                Between(2, 3))
  251. #define        (kTreePerNeutral,                0)
  252.  
  253. //////////////////////////////////////////////////////////////////////
  254. // forest definitions
  255. #define        (kForestFreeRadius,                7.0)
  256. #define        (kForestsPerPlayer,                2)
  257. #define        (kForestChaosLevel,                1)
  258. #define        (kMaxClumpsPerForest,                  2)
  259.  
  260. #elif Is4Players
  261. //////////////////////////////////////////////////////////////////////
  262. // 4 PLAYERS...
  263. //////////////////////////////////////////////////////////////////////
  264.  
  265. ResourceSeperation    6 
  266.  
  267. PlaceResourceInRing (Iron, 30, 35)
  268. PlaceResourceInRing (Gold, 30, 35)
  269.  
  270. //////////////////////////////////////////////////////////////////////
  271. // terrain definitions
  272. HeightMapSmoothness                    0
  273. #define        (kMaxIntElevation,            12)
  274. #define        (kElevationScale,                Between(.5, .5))
  275. #define        (kHeightMapChaos,                Between(15, 15))
  276.                                             
  277. #define        (kMinimumStartPositionToMapEdge        5)
  278. #define        (kOuterPushFromMapCenter        25)
  279. #define        (kInnerPushFromMapCenter         0)    
  280.     
  281. #define        (kConvergentSampleSize,            32) 
  282. #define        (kConvergentThreshold,            8)    
  283.  
  284. //////////////////////////////////////////////////////////////////////
  285. // player definitions
  286. #define        (kMaxAngleBetweenTeamMembers,        75.0)
  287. #define        (kPlayerInnerRadius,            0.6)
  288. #define        (kPlayerOuterRadius,            0.99)
  289. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  290. #define        (kPlayerPercentFlat,            Between(0.8, 0.8))
  291. #define        (kPlayerLandChaos,            0.8)
  292. #define        (kPlayerLandClumps,            Between(2, 2))
  293. #define        (kPlayerFlatChaos,            0.8)
  294. #define        (kPlayerFlatClumps,            Between(1, 2))
  295. #define        (kPlayerTreePercentage,            0.04)
  296.  
  297. //////////////////////////////////////////////////////////////////////
  298. // inner neutral definitions
  299. #define        (kNeutralInnerRadius,            0.1)
  300. #define        (kNeutralOuterRadius,            0.5)
  301. #define        (kNeutralOptimalFactor,            0.7)
  302. #define        (kNumInnerNeutrals,                 Between(11, 11))
  303. #define        (kInnerNeutralPercentLand,        0.2)
  304. #define        (kInnerNeutralPercentFlat,        Between(0.5, 0.5))
  305. #define        (kInnerNeutralTreePercentage,          0.1)
  306. #define        (kInnerNeutralLandChaos,        0.8)
  307. #define        (kInnerNeutralLandClumps,        Between(2, 2))
  308. #define        (kInnerNeutralFlatChaos,        0.8)
  309. #define        (kInnerNeutralFlatClumps,        Between(1, 1))
  310.  
  311. //////////////////////////////////////////////////////////////////////
  312. // outer neutral definitions
  313. #define        (kNumOuterNeutrals,            Between(20, 20))
  314. #define        (kOuterNeutralPercentLand,        0.5)
  315. #define        (kOuterNeutralPercentFlat,        Between(0.4, 0.4))
  316. #define        (kOuterNeutralTreePercentage,          0.1)
  317. #define        (kOuterNeutralLandChaos,        0.8)
  318. #define        (kOuterNeutralLandClumps,        Between(2, 2))
  319. #define        (kOuterNeutralFlatChaos,        0.8)
  320. #define        (kOuterNeutralFlatClumps,        Between(1, 1))
  321.  
  322. //////////////////////////////////////////////////////////////////////
  323. // resource definitions
  324. #define        (kMaxResourceElevation,            2)
  325. #define        (kResourceToEdgeDistance,        2)
  326. #define        (kResourceToWaterDistance,        3)
  327.  
  328. #define        (kAnimalPerPlayer,                0)
  329. #define        (kAnimalPerNeutral,                0)
  330.  
  331.  
  332. #define        (kBerryPerNeutral,                0)
  333.  
  334. #define        (kFishPerPlayer,                0)
  335. #define        (kFishPerNeutral,                0)
  336.  
  337. #define        (kGoldPerPlayer,                1)
  338. #define        (kGoldPerNeutral,                2)
  339.  
  340. #define        (kOilPerPlayer,                    0)
  341. #define        (kOilPerNeutral,                0)
  342.  
  343. #define        (kSteelPerPlayer,                1)
  344. #define        (kSteelPerNeutral,                2)
  345.  
  346. #define        (kStonePerPlayer,                1)
  347. #define        (kStonePerNeutral,                2)
  348.  
  349. #define        (kTreePerPlayer,                Between(2, 3))
  350. #define        (kTreePerNeutral,                0)
  351.  
  352. //////////////////////////////////////////////////////////////////////
  353. // forest definitions
  354. #define        (kForestFreeRadius,                7.0)
  355. #define        (kForestsPerPlayer,                2)
  356. #define        (kForestChaosLevel,                1)
  357. #define        (kMaxClumpsPerForest,                  2)
  358.  
  359.  
  360. #elif Is5Players
  361. //////////////////////////////////////////////////////////////////////
  362. // 5 PLAYERS...
  363. //////////////////////////////////////////////////////////////////////
  364.  
  365. ResourceSeperation    5 
  366.  
  367. //////////////////////////////////////////////////////////////////////
  368. // terrain definitions
  369. HeightMapSmoothness                    0
  370. #define        (kMaxIntElevation,            12)
  371. #define        (kElevationScale,                Between(.5, .5))
  372. #define        (kHeightMapChaos,                Between(15, 15))
  373.                                             
  374. #define        (kMinimumStartPositionToMapEdge        5)
  375. #define        (kOuterPushFromMapCenter        25)
  376. #define        (kInnerPushFromMapCenter         0)    
  377.     
  378. #define        (kConvergentSampleSize,            32) 
  379. #define        (kConvergentThreshold,            8)    
  380.  
  381. //////////////////////////////////////////////////////////////////////
  382. // player definitions
  383. #define        (kMaxAngleBetweenTeamMembers,        75.0)
  384. #define        (kPlayerInnerRadius,            0.6)
  385. #define        (kPlayerOuterRadius,            0.99)
  386. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  387. #define        (kPlayerPercentFlat,            Between(0.8, 0.8))
  388. #define        (kPlayerLandChaos,            0.8)
  389. #define        (kPlayerLandClumps,            Between(2, 2))
  390. #define        (kPlayerFlatChaos,            0.8)
  391. #define        (kPlayerFlatClumps,            Between(1, 2))
  392. #define        (kPlayerTreePercentage,            0.04)
  393.  
  394. //////////////////////////////////////////////////////////////////////
  395. // inner neutral definitions
  396. #define        (kNeutralInnerRadius,            0.1)
  397. #define        (kNeutralOuterRadius,            0.5)
  398. #define        (kNeutralOptimalFactor,            0.7)
  399. #define        (kNumInnerNeutrals,                 Between(11, 11))
  400. #define        (kInnerNeutralPercentLand,        0.2)
  401. #define        (kInnerNeutralPercentFlat,        Between(0.5, 0.5))
  402. #define        (kInnerNeutralTreePercentage,          0.1)
  403. #define        (kInnerNeutralLandChaos,        0.8)
  404. #define        (kInnerNeutralLandClumps,        Between(2, 2))
  405. #define        (kInnerNeutralFlatChaos,        0.8)
  406. #define        (kInnerNeutralFlatClumps,        Between(1, 1))
  407.  
  408. //////////////////////////////////////////////////////////////////////
  409. // outer neutral definitions
  410. #define        (kNumOuterNeutrals,            Between(20, 20))
  411. #define        (kOuterNeutralPercentLand,        0.5)
  412. #define        (kOuterNeutralPercentFlat,        Between(0.4, 0.4))
  413. #define        (kOuterNeutralTreePercentage,          0.1)
  414. #define        (kOuterNeutralLandChaos,        0.8)
  415. #define        (kOuterNeutralLandClumps,        Between(2, 2))
  416. #define        (kOuterNeutralFlatChaos,        0.8)
  417. #define        (kOuterNeutralFlatClumps,        Between(1, 1))
  418.  
  419. //////////////////////////////////////////////////////////////////////
  420. // resource definitions
  421. #define        (kMaxResourceElevation,            2)
  422. #define        (kResourceToEdgeDistance,        2)
  423. #define        (kResourceToWaterDistance,        3)
  424.  
  425. #define        (kAnimalPerPlayer,                0)
  426. #define        (kAnimalPerNeutral,                0)
  427.  
  428.  
  429. #define        (kBerryPerNeutral,                0)
  430.  
  431. #define        (kFishPerPlayer,                0)
  432. #define        (kFishPerNeutral,                0)
  433.  
  434. #define        (kGoldPerPlayer,                1)
  435. #define        (kGoldPerNeutral,                6)
  436.  
  437. #define        (kOilPerPlayer,                    0)
  438. #define        (kOilPerNeutral,                0)
  439.  
  440. #define        (kSteelPerPlayer,                1)
  441. #define        (kSteelPerNeutral,                6)
  442.  
  443. #define        (kStonePerPlayer,                1)
  444. #define        (kStonePerNeutral,                2)
  445.  
  446. #define        (kTreePerPlayer,                Between(2, 3))
  447. #define        (kTreePerNeutral,                0)
  448.  
  449. //////////////////////////////////////////////////////////////////////
  450. // forest definitions
  451. #define        (kForestFreeRadius,                7.0)
  452. #define        (kForestsPerPlayer,                2)
  453. #define        (kForestChaosLevel,                1)
  454. #define        (kMaxClumpsPerForest,                  2)
  455.  
  456. #elif Is6Players
  457. //////////////////////////////////////////////////////////////////////
  458. // 6 PLAYERS...
  459. //////////////////////////////////////////////////////////////////////
  460.  
  461. ResourceSeperation    5 
  462.  
  463. //////////////////////////////////////////////////////////////////////
  464. // terrain definitions
  465. HeightMapSmoothness                    0
  466. #define        (kMaxIntElevation,            12)
  467. #define        (kElevationScale,                Between(.5, .5))
  468. #define        (kHeightMapChaos,                Between(15, 15))
  469.                                             
  470. #define        (kMinimumStartPositionToMapEdge        5)
  471. #define        (kOuterPushFromMapCenter        25)
  472. #define        (kInnerPushFromMapCenter         0)    
  473.     
  474. #define        (kConvergentSampleSize,            32) 
  475. #define        (kConvergentThreshold,            8)
  476.  
  477. //////////////////////////////////////////////////////////////////////
  478. // player definitions
  479. #define        (kMaxAngleBetweenTeamMembers,        75.0)
  480. #define        (kPlayerInnerRadius,            0.6)
  481. #define        (kPlayerOuterRadius,            0.99)
  482. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  483. #define        (kPlayerPercentFlat,            Between(0.8, 0.8))
  484. #define        (kPlayerLandChaos,            0.8)
  485. #define        (kPlayerLandClumps,            Between(2, 2))
  486. #define        (kPlayerFlatChaos,            0.8)
  487. #define        (kPlayerFlatClumps,            Between(1, 2))
  488. #define        (kPlayerTreePercentage,            0.04)
  489.  
  490. //////////////////////////////////////////////////////////////////////
  491. // inner neutral definitions
  492. #define        (kNeutralInnerRadius,            0.1)
  493. #define        (kNeutralOuterRadius,            0.5)
  494. #define        (kNeutralOptimalFactor,            0.7)
  495. #define        (kNumInnerNeutrals,                 Between(11, 11))
  496. #define        (kInnerNeutralPercentLand,        0.2)
  497. #define        (kInnerNeutralPercentFlat,        Between(0.5, 0.5))
  498. #define        (kInnerNeutralTreePercentage,          0.1)
  499. #define        (kInnerNeutralLandChaos,        0.8)
  500. #define        (kInnerNeutralLandClumps,        Between(2, 2))
  501. #define        (kInnerNeutralFlatChaos,        0.8)
  502. #define        (kInnerNeutralFlatClumps,        Between(1, 1))
  503.  
  504. //////////////////////////////////////////////////////////////////////
  505. // outer neutral definitions
  506. #define        (kNumOuterNeutrals,            Between(20, 20))
  507. #define        (kOuterNeutralPercentLand,        0.5)
  508. #define        (kOuterNeutralPercentFlat,        Between(0.4, 0.4))
  509. #define        (kOuterNeutralTreePercentage,          0.1)
  510. #define        (kOuterNeutralLandChaos,        0.8)
  511. #define        (kOuterNeutralLandClumps,        Between(2, 2))
  512. #define        (kOuterNeutralFlatChaos,        0.8)
  513. #define        (kOuterNeutralFlatClumps,        Between(1, 1))
  514.  
  515. //////////////////////////////////////////////////////////////////////
  516. // resource definitions
  517. #define        (kMaxResourceElevation,            2)
  518. #define        (kResourceToEdgeDistance,        2)
  519. #define        (kResourceToWaterDistance,        3)
  520.  
  521. #define        (kAnimalPerPlayer,                0)
  522. #define        (kAnimalPerNeutral,                0)
  523.  
  524.  
  525. #define        (kBerryPerNeutral,                0)
  526.  
  527. #define        (kFishPerPlayer,                0)
  528. #define        (kFishPerNeutral,                0)
  529.  
  530. #define        (kGoldPerPlayer,                1)
  531. #define        (kGoldPerNeutral,                6)
  532.  
  533. #define        (kOilPerPlayer,                    0)
  534. #define        (kOilPerNeutral,                0)
  535.  
  536. #define        (kSteelPerPlayer,                1)
  537. #define        (kSteelPerNeutral,                6)
  538.  
  539. #define        (kStonePerPlayer,                1)
  540. #define        (kStonePerNeutral,                2)
  541.  
  542. #define        (kTreePerPlayer,                Between(2, 3))
  543. #define        (kTreePerNeutral,                0)
  544.  
  545. //////////////////////////////////////////////////////////////////////
  546. // forest definitions
  547. #define        (kForestFreeRadius,                7.0)
  548. #define        (kForestsPerPlayer,                2)
  549. #define        (kForestChaosLevel,                1)
  550. #define        (kMaxClumpsPerForest,                  2)
  551.  
  552.  
  553. #elif Is7Players
  554. //////////////////////////////////////////////////////////////////////
  555. // 7 PLAYERS...
  556. //////////////////////////////////////////////////////////////////////
  557.  
  558. ResourceSeperation    5 
  559.  
  560. //////////////////////////////////////////////////////////////////////
  561. // terrain definitions
  562. HeightMapSmoothness                    0
  563. #define        (kMaxIntElevation,            12)
  564. #define        (kElevationScale,                Between(.5, .5))
  565. #define        (kHeightMapChaos,                Between(15, 15))
  566.                                             
  567. #define        (kMinimumStartPositionToMapEdge        5)
  568. #define        (kOuterPushFromMapCenter        25)
  569. #define        (kInnerPushFromMapCenter         0)    
  570.     
  571. #define        (kConvergentSampleSize,            32) 
  572. #define        (kConvergentThreshold,            8)
  573.  
  574. //////////////////////////////////////////////////////////////////////
  575. // player definitions
  576. #define        (kMaxAngleBetweenTeamMembers,        75.0)
  577. #define        (kPlayerInnerRadius,            0.6)
  578. #define        (kPlayerOuterRadius,            0.99)
  579. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  580. #define        (kPlayerPercentFlat,            Between(0.8, 0.8))
  581. #define        (kPlayerLandChaos,            0.8)
  582. #define        (kPlayerLandClumps,            Between(2, 2))
  583. #define        (kPlayerFlatChaos,            0.8)
  584. #define        (kPlayerFlatClumps,            Between(1, 2))
  585. #define        (kPlayerTreePercentage,            0.04)
  586.  
  587. //////////////////////////////////////////////////////////////////////
  588. // inner neutral definitions
  589. #define        (kNeutralInnerRadius,            0.1)
  590. #define        (kNeutralOuterRadius,            0.5)
  591. #define        (kNeutralOptimalFactor,            0.7)
  592. #define        (kNumInnerNeutrals,                 Between(11, 11))
  593. #define        (kInnerNeutralPercentLand,        0.2)
  594. #define        (kInnerNeutralPercentFlat,        Between(0.5, 0.5))
  595. #define        (kInnerNeutralTreePercentage,          0.1)
  596. #define        (kInnerNeutralLandChaos,        0.8)
  597. #define        (kInnerNeutralLandClumps,        Between(2, 2))
  598. #define        (kInnerNeutralFlatChaos,        0.8)
  599. #define        (kInnerNeutralFlatClumps,        Between(1, 1))
  600.  
  601. //////////////////////////////////////////////////////////////////////
  602. // outer neutral definitions
  603. #define        (kNumOuterNeutrals,            Between(20, 20))
  604. #define        (kOuterNeutralPercentLand,        0.5)
  605. #define        (kOuterNeutralPercentFlat,        Between(0.4, 0.4))
  606. #define        (kOuterNeutralTreePercentage,          0.1)
  607. #define        (kOuterNeutralLandChaos,        0.8)
  608. #define        (kOuterNeutralLandClumps,        Between(2, 2))
  609. #define        (kOuterNeutralFlatChaos,        0.8)
  610. #define        (kOuterNeutralFlatClumps,        Between(1, 1))
  611.  
  612. //////////////////////////////////////////////////////////////////////
  613. // resource definitions
  614. #define        (kMaxResourceElevation,            2)
  615. #define        (kResourceToEdgeDistance,        2)
  616. #define        (kResourceToWaterDistance,        3)
  617.  
  618. #define        (kAnimalPerPlayer,                0)
  619. #define        (kAnimalPerNeutral,                0)
  620.  
  621.  
  622. #define        (kBerryPerNeutral,                0)
  623.  
  624. #define        (kFishPerPlayer,                0)
  625. #define        (kFishPerNeutral,                0)
  626.  
  627. #define        (kGoldPerPlayer,                1)
  628. #define        (kGoldPerNeutral,                6)
  629.  
  630. #define        (kOilPerPlayer,                    0)
  631. #define        (kOilPerNeutral,                0)
  632.  
  633. #define        (kSteelPerPlayer,                1)
  634. #define        (kSteelPerNeutral,                6)
  635.  
  636. #define        (kStonePerPlayer,                1)
  637. #define        (kStonePerNeutral,                2)
  638.  
  639. #define        (kTreePerPlayer,                Between(2, 3))
  640. #define        (kTreePerNeutral,                0)
  641.  
  642. //////////////////////////////////////////////////////////////////////
  643. // forest definitions
  644. #define        (kForestFreeRadius,                7.0)
  645. #define        (kForestsPerPlayer,                2)
  646. #define        (kForestChaosLevel,                1)
  647. #define        (kMaxClumpsPerForest,                  2)
  648.  
  649. #elif Is8Players
  650. //////////////////////////////////////////////////////////////////////
  651. // 8 PLAYERS...
  652. //////////////////////////////////////////////////////////////////////
  653.  
  654. ResourceSeperation    5 
  655.  
  656. //////////////////////////////////////////////////////////////////////
  657. // terrain definitions
  658. HeightMapSmoothness                    0
  659. #define        (kMaxIntElevation,            12)
  660. #define        (kElevationScale,                Between(.5, .5))
  661. #define        (kHeightMapChaos,                Between(15, 15))
  662.                                             
  663. #define        (kMinimumStartPositionToMapEdge        5)
  664. #define        (kOuterPushFromMapCenter        25)
  665. #define        (kInnerPushFromMapCenter         0)    
  666.     
  667. #define        (kConvergentSampleSize,            32) 
  668. #define        (kConvergentThreshold,            8)
  669.  
  670. //////////////////////////////////////////////////////////////////////
  671. // player definitions
  672. #define        (kMaxAngleBetweenTeamMembers,        75.0)
  673. #define        (kPlayerInnerRadius,            0.6)
  674. #define        (kPlayerOuterRadius,            0.99)
  675. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  676. #define        (kPlayerPercentFlat,            Between(0.8, 0.8))
  677. #define        (kPlayerLandChaos,            0.8)
  678. #define        (kPlayerLandClumps,            Between(2, 2))
  679. #define        (kPlayerFlatChaos,            0.8)
  680. #define        (kPlayerFlatClumps,            Between(1, 2))
  681. #define        (kPlayerTreePercentage,            0.04)
  682.  
  683. //////////////////////////////////////////////////////////////////////
  684. // inner neutral definitions
  685. #define        (kNeutralInnerRadius,            0.1)
  686. #define        (kNeutralOuterRadius,            0.5)
  687. #define        (kNeutralOptimalFactor,            0.7)
  688. #define        (kNumInnerNeutrals,                 Between(11, 11))
  689. #define        (kInnerNeutralPercentLand,        0.2)
  690. #define        (kInnerNeutralPercentFlat,        Between(0.5, 0.5))
  691. #define        (kInnerNeutralTreePercentage,          0.1)
  692. #define        (kInnerNeutralLandChaos,        0.8)
  693. #define        (kInnerNeutralLandClumps,        Between(2, 2))
  694. #define        (kInnerNeutralFlatChaos,        0.8)
  695. #define        (kInnerNeutralFlatClumps,        Between(1, 1))
  696.  
  697. //////////////////////////////////////////////////////////////////////
  698. // outer neutral definitions
  699. #define        (kNumOuterNeutrals,            Between(20, 20))
  700. #define        (kOuterNeutralPercentLand,        0.5)
  701. #define        (kOuterNeutralPercentFlat,        Between(0.4, 0.4))
  702. #define        (kOuterNeutralTreePercentage,          0.1)
  703. #define        (kOuterNeutralLandChaos,        0.8)
  704. #define        (kOuterNeutralLandClumps,        Between(2, 2))
  705. #define        (kOuterNeutralFlatChaos,        0.8)
  706. #define        (kOuterNeutralFlatClumps,        Between(1, 1))
  707.  
  708. //////////////////////////////////////////////////////////////////////
  709. // resource definitions
  710. #define        (kMaxResourceElevation,            2)
  711. #define        (kResourceToEdgeDistance,        2)
  712. #define        (kResourceToWaterDistance,        3)
  713.  
  714. #define        (kAnimalPerPlayer,                0)
  715. #define        (kAnimalPerNeutral,                0)
  716.  
  717.  
  718. #define        (kBerryPerNeutral,                0)
  719.  
  720. #define        (kFishPerPlayer,                0)
  721. #define        (kFishPerNeutral,                0)
  722.  
  723. #define        (kGoldPerPlayer,                1)
  724. #define        (kGoldPerNeutral,                6)
  725.  
  726. #define        (kOilPerPlayer,                    0)
  727. #define        (kOilPerNeutral,                0)
  728.  
  729. #define        (kSteelPerPlayer,                1)
  730. #define        (kSteelPerNeutral,                6)
  731.  
  732. #define        (kStonePerPlayer,                1)
  733. #define        (kStonePerNeutral,                2)
  734.  
  735. #define        (kTreePerPlayer,                Between(2, 3))
  736. #define        (kTreePerNeutral,                0)
  737.  
  738. //////////////////////////////////////////////////////////////////////
  739. // forest definitions
  740. #define        (kForestFreeRadius,                7.0)
  741. #define        (kForestsPerPlayer,                2)
  742. #define        (kForestChaosLevel,                1)
  743. #define        (kMaxClumpsPerForest,                  2)
  744.  
  745. #elif Is9Players
  746. //////////////////////////////////////////////////////////////////////
  747. // 9 PLAYERS...
  748. //////////////////////////////////////////////////////////////////////
  749.  
  750. //////////////////////////////////////////////////////////////////////
  751. // terrain definitions
  752. #define        (kMaxIntElevation,            15)
  753. #define        (kElevationScale,                Between(1, 1))
  754. #define        (kHeightMapChaos,                Between(30, 60))
  755.  
  756. #define        (kMinimumStartPositionToMapEdge    2)
  757. #define        (kOuterPushFromMapCenter        31)
  758. #define        (kInnerPushFromMapCenter         0)    
  759.                                             
  760. //////////////////////////////////////////////////////////////////////
  761. // player definitions
  762. #define        (kMaxAngleBetweenTeamMembers,        24.0)
  763. #define        (kPlayerInnerRadius,            0.6)
  764. #define        (kPlayerOuterRadius,            0.95)
  765. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  766. #define        (kPlayerPercentFlat,            Between(.8, .8))
  767. #define        (kPlayerLandChaos,            0.8)
  768. #define        (kPlayerLandClumps,            Between(2, 2))
  769. #define        (kPlayerFlatChaos,            0.8)
  770. #define        (kPlayerFlatClumps,            Between(1, 2))
  771. #define        (kPlayerTreePercentage,            0.08)
  772.  
  773. //////////////////////////////////////////////////////////////////////
  774. // inner neutral definitions
  775. #define        (kNeutralInnerRadius,            0.2)
  776. #define        (kNeutralOuterRadius,            0.5)
  777. #define        (kNeutralOptimalFactor,            0.7)
  778. #define        (kNumInnerNeutrals,                 Between(18, 18))
  779. #define        (kInnerNeutralPercentLand,        0.19)
  780. #define        (kInnerNeutralPercentFlat,        Between(0.8, 0.8))
  781. #define        (kInnerNeutralTreePercentage,          0.2)
  782. #define        (kInnerNeutralLandChaos,        0.8)
  783. #define        (kInnerNeutralLandClumps,        Between(2, 2))
  784. #define        (kInnerNeutralFlatChaos,        0.8)
  785. #define        (kInnerNeutralFlatClumps,        Between(1, 2))
  786.  
  787. //////////////////////////////////////////////////////////////////////
  788. // outer neutral definitions
  789. #define        (kNumOuterNeutrals,            Between(32, 32))
  790. #define        (kOuterNeutralPercentLand,        0.61)
  791. #define        (kOuterNeutralPercentFlat,        Between(0.8, 0.8))
  792. #define        (kOuterNeutralTreePercentage,          0.15)
  793. #define        (kOuterNeutralLandChaos,        0.8)
  794. #define        (kOuterNeutralLandClumps,        Between(2, 2))
  795. #define        (kOuterNeutralFlatChaos,        0.8)
  796. #define        (kOuterNeutralFlatClumps,        Between(1, 2))
  797.  
  798. //////////////////////////////////////////////////////////////////////
  799. // resource definitions
  800. #define        (kMaxResourceElevation,            4)
  801. #define        (kResourceToEdgeDistance,        2)
  802. #define        (kResourceToWaterDistance,        4)
  803.  
  804. #define        (kAnimalPerPlayer,            0)
  805. #define        (kAnimalPerNeutral,            0)
  806.  
  807.  
  808. #define        (kBerryPerNeutral,            0)
  809.  
  810. #define        (kFishPerPlayer,                0)
  811. #define        (kFishPerNeutral,                0)
  812.  
  813. #define        (kGoldPerPlayer,                1)
  814. #define        (kGoldPerNeutral,                19)
  815.  
  816. #define        (kOilPerPlayer,                0)
  817. #define        (kOilPerNeutral,                0)
  818.  
  819. #define        (kSteelPerPlayer,                1)
  820. #define        (kSteelPerNeutral,            19)
  821.  
  822. #define        (kStonePerPlayer,                1)
  823. #define        (kStonePerNeutral,            7)
  824.  
  825. #define        (kTreePerPlayer,                0)
  826. #define        (kTreePerNeutral,                0)
  827.  
  828.  
  829. //////////////////////////////////////////////////////////////////////
  830. // forest definitions
  831. #define        (kForestFreeRadius,                10.0)
  832. #define        (kForestsPerPlayer,                1 )
  833. #define        (kForestChaosLevel,                0.5)
  834. #define        (kMaxClumpsPerForest,                  2)
  835.  
  836.  
  837. #elif Is10Players
  838. //////////////////////////////////////////////////////////////////////
  839. // 10 PLAYERS...
  840. //////////////////////////////////////////////////////////////////////
  841.  
  842. //////////////////////////////////////////////////////////////////////
  843. // terrain definitions
  844. #define        (kMaxIntElevation,            15)
  845. #define        (kElevationScale,                Between(1, 1))
  846. #define        (kHeightMapChaos,                Between(30, 60))
  847.  
  848. #define        (kMinimumStartPositionToMapEdge    2)
  849. #define        (kOuterPushFromMapCenter        31)
  850. #define        (kInnerPushFromMapCenter         0)    
  851.                                             
  852. //////////////////////////////////////////////////////////////////////
  853. // player definitions
  854. #define        (kMaxAngleBetweenTeamMembers,        24.0)
  855. #define        (kPlayerInnerRadius,            0.6)
  856. #define        (kPlayerOuterRadius,            0.95)
  857. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  858. #define        (kPlayerPercentFlat,            Between(.8, .8))
  859. #define        (kPlayerLandChaos,            0.8)
  860. #define        (kPlayerLandClumps,            Between(2, 2))
  861. #define        (kPlayerFlatChaos,            0.8)
  862. #define        (kPlayerFlatClumps,            Between(1, 2))
  863. #define        (kPlayerTreePercentage,            0.08)
  864.  
  865. //////////////////////////////////////////////////////////////////////
  866. // inner neutral definitions
  867. #define        (kNeutralInnerRadius,            0.2)
  868. #define        (kNeutralOuterRadius,            0.5)
  869. #define        (kNeutralOptimalFactor,            0.7)
  870. #define        (kNumInnerNeutrals,                 Between(18, 18))
  871. #define        (kInnerNeutralPercentLand,        0.19)
  872. #define        (kInnerNeutralPercentFlat,        Between(0.8, 0.8))
  873. #define        (kInnerNeutralTreePercentage,          0.2)
  874. #define        (kInnerNeutralLandChaos,        0.8)
  875. #define        (kInnerNeutralLandClumps,        Between(2, 2))
  876. #define        (kInnerNeutralFlatChaos,        0.8)
  877. #define        (kInnerNeutralFlatClumps,        Between(1, 2))
  878.  
  879. //////////////////////////////////////////////////////////////////////
  880. // outer neutral definitions
  881. #define        (kNumOuterNeutrals,            Between(32, 32))
  882. #define        (kOuterNeutralPercentLand,        0.61)
  883. #define        (kOuterNeutralPercentFlat,        Between(0.8, 0.8))
  884. #define        (kOuterNeutralTreePercentage,          0.15)
  885. #define        (kOuterNeutralLandChaos,        0.8)
  886. #define        (kOuterNeutralLandClumps,        Between(2, 2))
  887. #define        (kOuterNeutralFlatChaos,        0.8)
  888. #define        (kOuterNeutralFlatClumps,        Between(1, 2))
  889.  
  890. //////////////////////////////////////////////////////////////////////
  891. // resource definitions
  892. #define        (kMaxResourceElevation,            4)
  893. #define        (kResourceToEdgeDistance,        2)
  894. #define        (kResourceToWaterDistance,        4)
  895.  
  896. #define        (kAnimalPerPlayer,            0)
  897. #define        (kAnimalPerNeutral,            0)
  898.  
  899.  
  900. #define        (kBerryPerNeutral,            0)
  901.  
  902. #define        (kFishPerPlayer,                0)
  903. #define        (kFishPerNeutral,                0)
  904.  
  905. #define        (kGoldPerPlayer,                1)
  906. #define        (kGoldPerNeutral,                19)
  907.  
  908. #define        (kOilPerPlayer,                0)
  909. #define        (kOilPerNeutral,                0)
  910.  
  911. #define        (kSteelPerPlayer,                1)
  912. #define        (kSteelPerNeutral,            19)
  913.  
  914. #define        (kStonePerPlayer,                1)
  915. #define        (kStonePerNeutral,            7)
  916.  
  917. #define        (kTreePerPlayer,                0)
  918. #define        (kTreePerNeutral,                0)
  919.  
  920.  
  921. //////////////////////////////////////////////////////////////////////
  922. // forest definitions
  923. #define        (kForestFreeRadius,                10.0)
  924. #define        (kForestsPerPlayer,                1 )
  925. #define        (kForestChaosLevel,                0.5)
  926. #define        (kMaxClumpsPerForest,                  2)
  927.  
  928.  
  929. #elif Is11Players
  930. //////////////////////////////////////////////////////////////////////
  931. // 11 PLAYERS...
  932. //////////////////////////////////////////////////////////////////////
  933.  
  934. //////////////////////////////////////////////////////////////////////
  935. // terrain definitions
  936. #define        (kMaxIntElevation,            15)
  937. #define        (kElevationScale,                Between(1, 1))
  938. #define        (kHeightMapChaos,                Between(30, 60))
  939.  
  940. #define        (kMinimumStartPositionToMapEdge    2)
  941. #define        (kOuterPushFromMapCenter        31)
  942. #define        (kInnerPushFromMapCenter         0)    
  943.                                             
  944. //////////////////////////////////////////////////////////////////////
  945. // player definitions
  946. #define        (kMaxAngleBetweenTeamMembers,        24.0)
  947. #define        (kPlayerInnerRadius,            0.6)
  948. #define        (kPlayerOuterRadius,            0.95)
  949. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  950. #define        (kPlayerPercentFlat,            Between(.8, .8))
  951. #define        (kPlayerLandChaos,            0.8)
  952. #define        (kPlayerLandClumps,            Between(2, 2))
  953. #define        (kPlayerFlatChaos,            0.8)
  954. #define        (kPlayerFlatClumps,            Between(1, 2))
  955. #define        (kPlayerTreePercentage,            0.08)
  956.  
  957. //////////////////////////////////////////////////////////////////////
  958. // inner neutral definitions
  959. #define        (kNeutralInnerRadius,            0.2)
  960. #define        (kNeutralOuterRadius,            0.5)
  961. #define        (kNeutralOptimalFactor,            0.7)
  962. #define        (kNumInnerNeutrals,                 Between(18, 18))
  963. #define        (kInnerNeutralPercentLand,        0.19)
  964. #define        (kInnerNeutralPercentFlat,        Between(0.8, 0.8))
  965. #define        (kInnerNeutralTreePercentage,          0.2)
  966. #define        (kInnerNeutralLandChaos,        0.8)
  967. #define        (kInnerNeutralLandClumps,        Between(2, 2))
  968. #define        (kInnerNeutralFlatChaos,        0.8)
  969. #define        (kInnerNeutralFlatClumps,        Between(1, 2))
  970.  
  971. //////////////////////////////////////////////////////////////////////
  972. // outer neutral definitions
  973. #define        (kNumOuterNeutrals,            Between(32, 32))
  974. #define        (kOuterNeutralPercentLand,        0.61)
  975. #define        (kOuterNeutralPercentFlat,        Between(0.8, 0.8))
  976. #define        (kOuterNeutralTreePercentage,          0.15)
  977. #define        (kOuterNeutralLandChaos,        0.8)
  978. #define        (kOuterNeutralLandClumps,        Between(2, 2))
  979. #define        (kOuterNeutralFlatChaos,        0.8)
  980. #define        (kOuterNeutralFlatClumps,        Between(1, 2))
  981.  
  982. //////////////////////////////////////////////////////////////////////
  983. // resource definitions
  984. #define        (kMaxResourceElevation,            4)
  985. #define        (kResourceToEdgeDistance,        2)
  986. #define        (kResourceToWaterDistance,        4)
  987.  
  988. #define        (kAnimalPerPlayer,            0)
  989. #define        (kAnimalPerNeutral,            0)
  990.  
  991.  
  992. #define        (kBerryPerNeutral,            0)
  993.  
  994. #define        (kFishPerPlayer,                0)
  995. #define        (kFishPerNeutral,                0)
  996.  
  997. #define        (kGoldPerPlayer,                1)
  998. #define        (kGoldPerNeutral,                19)
  999.  
  1000. #define        (kOilPerPlayer,                0)
  1001. #define        (kOilPerNeutral,                0)
  1002.  
  1003. #define        (kSteelPerPlayer,                1)
  1004. #define        (kSteelPerNeutral,            19)
  1005.  
  1006. #define        (kStonePerPlayer,                1)
  1007. #define        (kStonePerNeutral,            7)
  1008.  
  1009. #define        (kTreePerPlayer,                0)
  1010. #define        (kTreePerNeutral,                0)
  1011.  
  1012.  
  1013. //////////////////////////////////////////////////////////////////////
  1014. // forest definitions
  1015. #define        (kForestFreeRadius,                10.0)
  1016. #define        (kForestsPerPlayer,                1 )
  1017. #define        (kForestChaosLevel,                0.5)
  1018. #define        (kMaxClumpsPerForest,                  2)
  1019.  
  1020.  
  1021. #elif Is12Players
  1022. //////////////////////////////////////////////////////////////////////
  1023. // 12 PLAYERS...
  1024. //////////////////////////////////////////////////////////////////////
  1025.  
  1026. //////////////////////////////////////////////////////////////////////
  1027. // terrain definitions
  1028. #define        (kMaxIntElevation,            15)
  1029. #define        (kElevationScale,                Between(1, 1))
  1030. #define        (kHeightMapChaos,                Between(30, 60))
  1031.  
  1032. #define        (kMinimumStartPositionToMapEdge    2)
  1033. #define        (kOuterPushFromMapCenter        31)
  1034. #define        (kInnerPushFromMapCenter         0)    
  1035.                                             
  1036. //////////////////////////////////////////////////////////////////////
  1037. // player definitions
  1038. #define        (kMaxAngleBetweenTeamMembers,        24.0)
  1039. #define        (kPlayerInnerRadius,            0.6)
  1040. #define        (kPlayerOuterRadius,            0.95)
  1041. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1042. #define        (kPlayerPercentFlat,            Between(.8, .8))
  1043. #define        (kPlayerLandChaos,            0.8)
  1044. #define        (kPlayerLandClumps,            Between(2, 2))
  1045. #define        (kPlayerFlatChaos,            0.8)
  1046. #define        (kPlayerFlatClumps,            Between(1, 2))
  1047. #define        (kPlayerTreePercentage,            0.08)
  1048.  
  1049. //////////////////////////////////////////////////////////////////////
  1050. // inner neutral definitions
  1051. #define        (kNeutralInnerRadius,            0.2)
  1052. #define        (kNeutralOuterRadius,            0.5)
  1053. #define        (kNeutralOptimalFactor,            0.7)
  1054. #define        (kNumInnerNeutrals,                 Between(18, 18))
  1055. #define        (kInnerNeutralPercentLand,        0.19)
  1056. #define        (kInnerNeutralPercentFlat,        Between(0.8, 0.8))
  1057. #define        (kInnerNeutralTreePercentage,          0.2)
  1058. #define        (kInnerNeutralLandChaos,        0.8)
  1059. #define        (kInnerNeutralLandClumps,        Between(2, 2))
  1060. #define        (kInnerNeutralFlatChaos,        0.8)
  1061. #define        (kInnerNeutralFlatClumps,        Between(1, 2))
  1062.  
  1063. //////////////////////////////////////////////////////////////////////
  1064. // outer neutral definitions
  1065. #define        (kNumOuterNeutrals,            Between(32, 32))
  1066. #define        (kOuterNeutralPercentLand,        0.61)
  1067. #define        (kOuterNeutralPercentFlat,        Between(0.8, 0.8))
  1068. #define        (kOuterNeutralTreePercentage,          0.15)
  1069. #define        (kOuterNeutralLandChaos,        0.8)
  1070. #define        (kOuterNeutralLandClumps,        Between(2, 2))
  1071. #define        (kOuterNeutralFlatChaos,        0.8)
  1072. #define        (kOuterNeutralFlatClumps,        Between(1, 2))
  1073.  
  1074. //////////////////////////////////////////////////////////////////////
  1075. // resource definitions
  1076. #define        (kMaxResourceElevation,            4)
  1077. #define        (kResourceToEdgeDistance,        2)
  1078. #define        (kResourceToWaterDistance,        4)
  1079.  
  1080. #define        (kAnimalPerPlayer,            0)
  1081. #define        (kAnimalPerNeutral,            0)
  1082.  
  1083.  
  1084. #define        (kBerryPerNeutral,            0)
  1085.  
  1086. #define        (kFishPerPlayer,                0)
  1087. #define        (kFishPerNeutral,                0)
  1088.  
  1089. #define        (kGoldPerPlayer,                1)
  1090. #define        (kGoldPerNeutral,                19)
  1091.  
  1092. #define        (kOilPerPlayer,                0)
  1093. #define        (kOilPerNeutral,                0)
  1094.  
  1095. #define        (kSteelPerPlayer,                1)
  1096. #define        (kSteelPerNeutral,            19)
  1097.  
  1098. #define        (kStonePerPlayer,                1)
  1099. #define        (kStonePerNeutral,            7)
  1100.  
  1101. #define        (kTreePerPlayer,                0)
  1102. #define        (kTreePerNeutral,                0)
  1103.  
  1104.  
  1105. //////////////////////////////////////////////////////////////////////
  1106. // forest definitions
  1107. #define        (kForestFreeRadius,                10.0)
  1108. #define        (kForestsPerPlayer,                1 )
  1109. #define        (kForestChaosLevel,                0.5)
  1110. #define        (kMaxClumpsPerForest,                  2)
  1111.  
  1112.  
  1113. #elif Is13Players
  1114. //////////////////////////////////////////////////////////////////////
  1115. // 13 PLAYERS...
  1116. //////////////////////////////////////////////////////////////////////
  1117.  
  1118. //////////////////////////////////////////////////////////////////////
  1119. // terrain definitions
  1120. #define        (kMaxIntElevation,            15)
  1121. #define        (kElevationScale,                Between(1, 1))
  1122. #define        (kHeightMapChaos,                Between(30, 60))
  1123.  
  1124. #define        (kMinimumStartPositionToMapEdge    2)
  1125. #define        (kOuterPushFromMapCenter        31)
  1126. #define        (kInnerPushFromMapCenter         0)    
  1127.                                             
  1128. //////////////////////////////////////////////////////////////////////
  1129. // player definitions
  1130. #define        (kMaxAngleBetweenTeamMembers,        24.0)
  1131. #define        (kPlayerInnerRadius,            0.6)
  1132. #define        (kPlayerOuterRadius,            0.95)
  1133. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1134. #define        (kPlayerPercentFlat,            Between(.8, .8))
  1135. #define        (kPlayerLandChaos,            0.8)
  1136. #define        (kPlayerLandClumps,            Between(2, 2))
  1137. #define        (kPlayerFlatChaos,            0.8)
  1138. #define        (kPlayerFlatClumps,            Between(1, 2))
  1139. #define        (kPlayerTreePercentage,            0.08)
  1140.  
  1141. //////////////////////////////////////////////////////////////////////
  1142. // inner neutral definitions
  1143. #define        (kNeutralInnerRadius,            0.2)
  1144. #define        (kNeutralOuterRadius,            0.5)
  1145. #define        (kNeutralOptimalFactor,            0.7)
  1146. #define        (kNumInnerNeutrals,                 Between(18, 18))
  1147. #define        (kInnerNeutralPercentLand,        0.19)
  1148. #define        (kInnerNeutralPercentFlat,        Between(0.8, 0.8))
  1149. #define        (kInnerNeutralTreePercentage,          0.2)
  1150. #define        (kInnerNeutralLandChaos,        0.8)
  1151. #define        (kInnerNeutralLandClumps,        Between(2, 2))
  1152. #define        (kInnerNeutralFlatChaos,        0.8)
  1153. #define        (kInnerNeutralFlatClumps,        Between(1, 2))
  1154.  
  1155. //////////////////////////////////////////////////////////////////////
  1156. // outer neutral definitions
  1157. #define        (kNumOuterNeutrals,            Between(32, 32))
  1158. #define        (kOuterNeutralPercentLand,        0.61)
  1159. #define        (kOuterNeutralPercentFlat,        Between(0.8, 0.8))
  1160. #define        (kOuterNeutralTreePercentage,          0.15)
  1161. #define        (kOuterNeutralLandChaos,        0.8)
  1162. #define        (kOuterNeutralLandClumps,        Between(2, 2))
  1163. #define        (kOuterNeutralFlatChaos,        0.8)
  1164. #define        (kOuterNeutralFlatClumps,        Between(1, 2))
  1165.  
  1166. //////////////////////////////////////////////////////////////////////
  1167. // resource definitions
  1168. #define        (kMaxResourceElevation,            4)
  1169. #define        (kResourceToEdgeDistance,        2)
  1170. #define        (kResourceToWaterDistance,        4)
  1171.  
  1172. #define        (kAnimalPerPlayer,            0)
  1173. #define        (kAnimalPerNeutral,            0)
  1174.  
  1175.  
  1176. #define        (kBerryPerNeutral,            0)
  1177.  
  1178. #define        (kFishPerPlayer,                0)
  1179. #define        (kFishPerNeutral,                0)
  1180.  
  1181. #define        (kGoldPerPlayer,                1)
  1182. #define        (kGoldPerNeutral,                19)
  1183.  
  1184. #define        (kOilPerPlayer,                0)
  1185. #define        (kOilPerNeutral,                0)
  1186.  
  1187. #define        (kSteelPerPlayer,                1)
  1188. #define        (kSteelPerNeutral,            19)
  1189.  
  1190. #define        (kStonePerPlayer,                1)
  1191. #define        (kStonePerNeutral,            7)
  1192.  
  1193. #define        (kTreePerPlayer,                0)
  1194. #define        (kTreePerNeutral,                0)
  1195.  
  1196.  
  1197. //////////////////////////////////////////////////////////////////////
  1198. // forest definitions
  1199. #define        (kForestFreeRadius,                10.0)
  1200. #define        (kForestsPerPlayer,                1 )
  1201. #define        (kForestChaosLevel,                0.5)
  1202. #define        (kMaxClumpsPerForest,                  2)
  1203.  
  1204.  
  1205. #elif Is14Players
  1206. //////////////////////////////////////////////////////////////////////
  1207. // 14 PLAYERS...
  1208. //////////////////////////////////////////////////////////////////////
  1209.  
  1210. //////////////////////////////////////////////////////////////////////
  1211. // terrain definitions
  1212. #define        (kMaxIntElevation,            15)
  1213. #define        (kElevationScale,                Between(1, 1))
  1214. #define        (kHeightMapChaos,                Between(30, 60))
  1215.  
  1216. #define        (kMinimumStartPositionToMapEdge    2)
  1217. #define        (kOuterPushFromMapCenter        31)
  1218. #define        (kInnerPushFromMapCenter         0)    
  1219.                                             
  1220. //////////////////////////////////////////////////////////////////////
  1221. // player definitions
  1222. #define        (kMaxAngleBetweenTeamMembers,        24.0)
  1223. #define        (kPlayerInnerRadius,            0.6)
  1224. #define        (kPlayerOuterRadius,            0.95)
  1225. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1226. #define        (kPlayerPercentFlat,            Between(.8, .8))
  1227. #define        (kPlayerLandChaos,            0.8)
  1228. #define        (kPlayerLandClumps,            Between(2, 2))
  1229. #define        (kPlayerFlatChaos,            0.8)
  1230. #define        (kPlayerFlatClumps,            Between(1, 2))
  1231. #define        (kPlayerTreePercentage,            0.08)
  1232.  
  1233. //////////////////////////////////////////////////////////////////////
  1234. // inner neutral definitions
  1235. #define        (kNeutralInnerRadius,            0.2)
  1236. #define        (kNeutralOuterRadius,            0.5)
  1237. #define        (kNeutralOptimalFactor,            0.7)
  1238. #define        (kNumInnerNeutrals,                 Between(18, 18))
  1239. #define        (kInnerNeutralPercentLand,        0.19)
  1240. #define        (kInnerNeutralPercentFlat,        Between(0.8, 0.8))
  1241. #define        (kInnerNeutralTreePercentage,          0.2)
  1242. #define        (kInnerNeutralLandChaos,        0.8)
  1243. #define        (kInnerNeutralLandClumps,        Between(2, 2))
  1244. #define        (kInnerNeutralFlatChaos,        0.8)
  1245. #define        (kInnerNeutralFlatClumps,        Between(1, 2))
  1246.  
  1247. //////////////////////////////////////////////////////////////////////
  1248. // outer neutral definitions
  1249. #define        (kNumOuterNeutrals,            Between(32, 32))
  1250. #define        (kOuterNeutralPercentLand,        0.61)
  1251. #define        (kOuterNeutralPercentFlat,        Between(0.8, 0.8))
  1252. #define        (kOuterNeutralTreePercentage,          0.15)
  1253. #define        (kOuterNeutralLandChaos,        0.8)
  1254. #define        (kOuterNeutralLandClumps,        Between(2, 2))
  1255. #define        (kOuterNeutralFlatChaos,        0.8)
  1256. #define        (kOuterNeutralFlatClumps,        Between(1, 2))
  1257.  
  1258. //////////////////////////////////////////////////////////////////////
  1259. // resource definitions
  1260. #define        (kMaxResourceElevation,            4)
  1261. #define        (kResourceToEdgeDistance,        2)
  1262. #define        (kResourceToWaterDistance,        4)
  1263.  
  1264. #define        (kAnimalPerPlayer,            0)
  1265. #define        (kAnimalPerNeutral,            0)
  1266.  
  1267.  
  1268. #define        (kBerryPerNeutral,            0)
  1269.  
  1270. #define        (kFishPerPlayer,                0)
  1271. #define        (kFishPerNeutral,                0)
  1272.  
  1273. #define        (kGoldPerPlayer,                1)
  1274. #define        (kGoldPerNeutral,                19)
  1275.  
  1276. #define        (kOilPerPlayer,                0)
  1277. #define        (kOilPerNeutral,                0)
  1278.  
  1279. #define        (kSteelPerPlayer,                1)
  1280. #define        (kSteelPerNeutral,            19)
  1281.  
  1282. #define        (kStonePerPlayer,                1)
  1283. #define        (kStonePerNeutral,            7)
  1284.  
  1285. #define        (kTreePerPlayer,                0)
  1286. #define        (kTreePerNeutral,                0)
  1287.  
  1288.  
  1289. //////////////////////////////////////////////////////////////////////
  1290. // forest definitions
  1291. #define        (kForestFreeRadius,                10.0)
  1292. #define        (kForestsPerPlayer,                1 )
  1293. #define        (kForestChaosLevel,                0.5)
  1294. #define        (kMaxClumpsPerForest,                  2)
  1295.  
  1296.  
  1297. #elif Is15Players
  1298. //////////////////////////////////////////////////////////////////////
  1299. // 15 PLAYERS...
  1300. //////////////////////////////////////////////////////////////////////
  1301.  
  1302. //////////////////////////////////////////////////////////////////////
  1303. // terrain definitions
  1304. #define        (kMaxIntElevation,            15)
  1305. #define        (kElevationScale,                Between(1, 1))
  1306. #define        (kHeightMapChaos,                Between(30, 60))
  1307.  
  1308. #define        (kMinimumStartPositionToMapEdge    2)
  1309. #define        (kOuterPushFromMapCenter        31)
  1310. #define        (kInnerPushFromMapCenter         0)    
  1311.                                             
  1312. //////////////////////////////////////////////////////////////////////
  1313. // player definitions
  1314. #define        (kMaxAngleBetweenTeamMembers,        24.0)
  1315. #define        (kPlayerInnerRadius,            0.6)
  1316. #define        (kPlayerOuterRadius,            0.95)
  1317. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1318. #define        (kPlayerPercentFlat,            Between(.8, .8))
  1319. #define        (kPlayerLandChaos,            0.8)
  1320. #define        (kPlayerLandClumps,            Between(2, 2))
  1321. #define        (kPlayerFlatChaos,            0.8)
  1322. #define        (kPlayerFlatClumps,            Between(1, 2))
  1323. #define        (kPlayerTreePercentage,            0.08)
  1324.  
  1325. //////////////////////////////////////////////////////////////////////
  1326. // inner neutral definitions
  1327. #define        (kNeutralInnerRadius,            0.2)
  1328. #define        (kNeutralOuterRadius,            0.5)
  1329. #define        (kNeutralOptimalFactor,            0.7)
  1330. #define        (kNumInnerNeutrals,                 Between(18, 18))
  1331. #define        (kInnerNeutralPercentLand,        0.19)
  1332. #define        (kInnerNeutralPercentFlat,        Between(0.8, 0.8))
  1333. #define        (kInnerNeutralTreePercentage,          0.2)
  1334. #define        (kInnerNeutralLandChaos,        0.8)
  1335. #define        (kInnerNeutralLandClumps,        Between(2, 2))
  1336. #define        (kInnerNeutralFlatChaos,        0.8)
  1337. #define        (kInnerNeutralFlatClumps,        Between(1, 2))
  1338.  
  1339. //////////////////////////////////////////////////////////////////////
  1340. // outer neutral definitions
  1341. #define        (kNumOuterNeutrals,            Between(32, 32))
  1342. #define        (kOuterNeutralPercentLand,        0.61)
  1343. #define        (kOuterNeutralPercentFlat,        Between(0.8, 0.8))
  1344. #define        (kOuterNeutralTreePercentage,          0.15)
  1345. #define        (kOuterNeutralLandChaos,        0.8)
  1346. #define        (kOuterNeutralLandClumps,        Between(2, 2))
  1347. #define        (kOuterNeutralFlatChaos,        0.8)
  1348. #define        (kOuterNeutralFlatClumps,        Between(1, 2))
  1349.  
  1350. //////////////////////////////////////////////////////////////////////
  1351. // resource definitions
  1352. #define        (kMaxResourceElevation,            4)
  1353. #define        (kResourceToEdgeDistance,        2)
  1354. #define        (kResourceToWaterDistance,        4)
  1355.  
  1356. #define        (kAnimalPerPlayer,            0)
  1357. #define        (kAnimalPerNeutral,            0)
  1358.  
  1359.  
  1360. #define        (kBerryPerNeutral,            0)
  1361.  
  1362. #define        (kFishPerPlayer,                0)
  1363. #define        (kFishPerNeutral,                0)
  1364.  
  1365. #define        (kGoldPerPlayer,                1)
  1366. #define        (kGoldPerNeutral,                19)
  1367.  
  1368. #define        (kOilPerPlayer,                0)
  1369. #define        (kOilPerNeutral,                0)
  1370.  
  1371. #define        (kSteelPerPlayer,                1)
  1372. #define        (kSteelPerNeutral,            19)
  1373.  
  1374. #define        (kStonePerPlayer,                1)
  1375. #define        (kStonePerNeutral,            7)
  1376.  
  1377. #define        (kTreePerPlayer,                0)
  1378. #define        (kTreePerNeutral,                0)
  1379.  
  1380.  
  1381. //////////////////////////////////////////////////////////////////////
  1382. // forest definitions
  1383. #define        (kForestFreeRadius,                10.0)
  1384. #define        (kForestsPerPlayer,                1 )
  1385. #define        (kForestChaosLevel,                0.5)
  1386. #define        (kMaxClumpsPerForest,                  2)
  1387.  
  1388.  
  1389. #elif Is16Players
  1390. //////////////////////////////////////////////////////////////////////
  1391. // 16 PLAYERS...
  1392. //////////////////////////////////////////////////////////////////////
  1393.  
  1394. //////////////////////////////////////////////////////////////////////
  1395. // terrain definitions
  1396. #define        (kMaxIntElevation,            15)
  1397. #define        (kElevationScale,                Between(1, 1))
  1398. #define        (kHeightMapChaos,                Between(30, 60))
  1399.  
  1400. #define        (kMinimumStartPositionToMapEdge    2)
  1401. #define        (kOuterPushFromMapCenter        31)
  1402. #define        (kInnerPushFromMapCenter         0)    
  1403.                                             
  1404. //////////////////////////////////////////////////////////////////////
  1405. // player definitions
  1406. #define        (kMaxAngleBetweenTeamMembers,        24.0)
  1407. #define        (kPlayerInnerRadius,            0.6)
  1408. #define        (kPlayerOuterRadius,            0.95)
  1409. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1410. #define        (kPlayerPercentFlat,            Between(.8, .8))
  1411. #define        (kPlayerLandChaos,            0.8)
  1412. #define        (kPlayerLandClumps,            Between(2, 2))
  1413. #define        (kPlayerFlatChaos,            0.8)
  1414. #define        (kPlayerFlatClumps,            Between(1, 2))
  1415. #define        (kPlayerTreePercentage,            0.08)
  1416.  
  1417. //////////////////////////////////////////////////////////////////////
  1418. // inner neutral definitions
  1419. #define        (kNeutralInnerRadius,            0.2)
  1420. #define        (kNeutralOuterRadius,            0.5)
  1421. #define        (kNeutralOptimalFactor,            0.7)
  1422. #define        (kNumInnerNeutrals,                 Between(18, 18))
  1423. #define        (kInnerNeutralPercentLand,        0.19)
  1424. #define        (kInnerNeutralPercentFlat,        Between(0.8, 0.8))
  1425. #define        (kInnerNeutralTreePercentage,          0.2)
  1426. #define        (kInnerNeutralLandChaos,        0.8)
  1427. #define        (kInnerNeutralLandClumps,        Between(2, 2))
  1428. #define        (kInnerNeutralFlatChaos,        0.8)
  1429. #define        (kInnerNeutralFlatClumps,        Between(1, 2))
  1430.  
  1431. //////////////////////////////////////////////////////////////////////
  1432. // outer neutral definitions
  1433. #define        (kNumOuterNeutrals,            Between(32, 32))
  1434. #define        (kOuterNeutralPercentLand,        0.61)
  1435. #define        (kOuterNeutralPercentFlat,        Between(0.8, 0.8))
  1436. #define        (kOuterNeutralTreePercentage,          0.15)
  1437. #define        (kOuterNeutralLandChaos,        0.8)
  1438. #define        (kOuterNeutralLandClumps,        Between(2, 2))
  1439. #define        (kOuterNeutralFlatChaos,        0.8)
  1440. #define        (kOuterNeutralFlatClumps,        Between(1, 2))
  1441.  
  1442. //////////////////////////////////////////////////////////////////////
  1443. // resource definitions
  1444. #define        (kMaxResourceElevation,            4)
  1445. #define        (kResourceToEdgeDistance,        2)
  1446. #define        (kResourceToWaterDistance,        4)
  1447.  
  1448. #define        (kAnimalPerPlayer,            0)
  1449. #define        (kAnimalPerNeutral,            0)
  1450.  
  1451.  
  1452. #define        (kBerryPerNeutral,            0)
  1453.  
  1454. #define        (kFishPerPlayer,                0)
  1455. #define        (kFishPerNeutral,                0)
  1456.  
  1457. #define        (kGoldPerPlayer,                1)
  1458. #define        (kGoldPerNeutral,                19)
  1459.  
  1460. #define        (kOilPerPlayer,                0)
  1461. #define        (kOilPerNeutral,                0)
  1462.  
  1463. #define        (kSteelPerPlayer,                1)
  1464. #define        (kSteelPerNeutral,            19)
  1465.  
  1466. #define        (kStonePerPlayer,                1)
  1467. #define        (kStonePerNeutral,            7)
  1468.  
  1469. #define        (kTreePerPlayer,                0)
  1470. #define        (kTreePerNeutral,                0)
  1471.  
  1472.  
  1473. //////////////////////////////////////////////////////////////////////
  1474. // forest definitions
  1475. #define        (kForestFreeRadius,                10.0)
  1476. #define        (kForestsPerPlayer,                1 )
  1477. #define        (kForestChaosLevel,                0.5)
  1478. #define        (kMaxClumpsPerForest,                  2)
  1479.  
  1480.  
  1481. //////////////////////////////////////////////////////////////////////
  1482. // End of if...elif... command
  1483. #endif
  1484.  
  1485. #endif        // NOTDEFINED(PLAINS_LARGE_RMV)